﻿using System;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;
using System.IO;

namespace HZ
{
    

    #region AllAboutNumberConvert
    [Obsolete("该方法已过期，请使用ConvertUtil代替")]
    public static class MathUtil
    {
        #region 数字方面
        /// <summary>
        /// 将字符串转换为数字的方法,失败返回默认值。
        /// </summary>
        /// <param name="s">要转换的字符串</param>
        /// <param name="defaultvalue">要返回的默认值。</param>
        /// <returns>返回的数字</returns>
        [Obsolete("该方法已过期，请使用ConvertUtil代替")]
        public static int SToI(string s, int defaultvalue)
        {
            int result = defaultvalue;
            if (int.TryParse(s, out result))
            {
                return result;
            }
            else
            {
                return defaultvalue;
            }
        }

        /// <summary>
        /// 将字符串转换为数字的方法,失败返回0。
        /// </summary>
        /// <param name="s">string</param>
        /// <returns>int</returns>
        [Obsolete("该方法已过期，请使用ConvertUtil代替")]
        public static int SToI(string s)
        {
            return SToI(s, 0);
        }

        /// <summary>
        /// 将字符串转换为浮点数的方法，转换之间请先检测下MathUtil.IsFloat，失败返回0
        /// </summary>
        /// <param name="s"></param>
        /// <returns></returns>
        [Obsolete("该方法已过期，请使用ConvertUtil代替")]
        public static double SToF(string s)
        {
            return SToF(s, 0);
        }
        [Obsolete("该方法已过期，请使用ConvertUtil代替")]
        public static double SToF(string s, double defaultvalue)
        {
            double result = defaultvalue;
            double.TryParse(s, out result);
            return result;
        }
        /// <summary>
        /// 是否自然数
        /// </summary>
        [Obsolete("该方法已过期，请使用Fun类的静态函数代替")]
        public static bool IsUInt(string s)
        {

            Regex r = new Regex(@"^\d+$");
            return r.IsMatch(s);
        }
        /// <summary>
        /// 是否非负浮点数.
        /// </summary>
        [Obsolete("该方法已过期，请使用Fun类的静态函数代替")]
        public static bool IsUFloat(string s)
        {
            Regex r = new Regex(@"^(\d+)(\.\d+)?$");
            return r.IsMatch(s);
        }
        /// <summary>
        /// 是否整数
        /// </summary>
        [Obsolete("该方法已过期，请使用Fun类的静态函数代替")]
        public static bool IsInt(string s)
        {
            Regex r = new Regex(@"^-?\d+$");
            return r.IsMatch(s);
        }
        [Obsolete("该方法已过期，请使用Fun类的静态函数代替")]
        public static bool IsFloat(string s)
        {
            Regex r = new Regex(@"^(-?\d+)(\.\d+)?$");
            return r.IsMatch(s);
        }

        /// <summary>
        /// 将对象转换为string
        /// </summary>
        /// <param name="obj">对象</param>
        /// <returns>string</returns>
        [Obsolete("该方法已过期，请使用ConvertUtil代替")]
        public static string ObjToStr(object obj)
        {
            if (obj == null)
            {
                return "";
            }
            else
            {
                return obj.ToString();
            }
        }
        #endregion

        /// <summary>
        /// 将浮点数转换为字节数组
        /// </summary>
        /// <param name="f"></param>
        /// <returns></returns>
        [Obsolete("该方法已过期，请使用ConvertUtil代替")]
        public static byte[] FloatToByte(float f)
        {
            return BitConverter.GetBytes(f);
        }
        /// <summary>
        /// 从4byte字节数组转换为float
        /// </summary>
        /// <param name="bytes"></param>
        /// <returns></returns>
        [Obsolete("该方法已过期，请使用ConvertUtil代替")]
        public static float ByteToFload(byte[] bytes)
        {
            return BitConverter.ToSingle(bytes, 0);
        }
        /// <summary>
        /// 把Hex字符串转换为字节组
        /// </summary>
        [Obsolete("该方法已过期，请使用Fun类的静态函数代替")]
        public static byte[] HexStrToByte(string hexstr)
        {
            byte[] buf = new byte[hexstr.Length / 2];
            for (int i = 0; i < hexstr.Length / 2; i++)
            {
                buf[i] = byte.Parse(hexstr.Substring(i * 2, 2), System.Globalization.NumberStyles.HexNumber);
            }
            return buf;
        }
        /// <summary>
        /// 将字节数组转换为Hex字符串
        /// </summary>
        [Obsolete("该方法已过期，请使用Fun类的静态函数代替")]
        public static string ByteToHexStr(byte[] buf)
        {
            System.Text.StringBuilder sb = new StringBuilder();
            for (int i = 0; i < buf.Length; i++)
            {
                sb.Append(buf[i].ToString("X2"));
            }
            return sb.ToString();
        }
    }
    #endregion

    #region md5
    
    public static class Md5
    {
        [System.Obsolete("use HZ.Fun.GetMd5() Instead")]
        public static string GetMd5(string s)
        {
            return HZ.Fun2.GetMd5(s);
        }
    }
    #endregion

    
}